package com.devMode.Factory.AbstractFactory;

/**
 * 抽象工厂模式创建的是对象的家族，也就是很多种对象，并且这些对象是一起被创建出来的，
 * 并且这些对象之间是相关的，工厂方法模式只是用于创建一个对象
 * 抽象工厂模式用到了工厂方法模式来创建单一对象，AbstractFactory中的createProduct1和createProduct2，都是让子类来实现的
 * Clients需要创建出好几种对象组合在一起，成为一个对象，抽象工厂在某种程度上细分了一个对象实体的多个组成部分
 *
 */
public class AbstractFactoryMode {

    public static void main(String[] args) {
        /**
         * 可以创建不同族的产品组合
         */
        AbstractFactory factory1 = new ConcreateFactory1();
        AbstractFactory factory2 = new ConcreateFactory2();

        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();

        productA1.show();
        productB1.take();

        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();

        productA2.show();
        productB2.take();
    }
}



interface ProductA{
    void show();
}

interface ProductB{
    void take();
}

class ProductA1 implements ProductA{

    @Override
    public void show() {
        System.out.println("product 1 show");
    }
}

class ProruductA2 implements  ProductA{

    @Override
    public void show() {
        System.out.println("product 2 show" );
    }
}

class ProductB1 implements ProductB{

    @Override
    public void take() {
        System.out.println("product 1 take");
    }
}

class ProruductB2 implements  ProductB{

    @Override
    public void take() {
        System.out.println("product 2 take");
    }
}

abstract class AbstractFactory{
    abstract ProductA createProductA();
    abstract ProductB createProductB();
}

class ConcreateFactory1 extends AbstractFactory{

    @Override
    ProductA createProductA() {
        return new ProductA1();
    }

    @Override
    ProductB createProductB() {
        return new ProductB1();
    }
}


class ConcreateFactory2 extends AbstractFactory{

    @Override
    ProductA createProductA() {
        return new ProruductA2();
    }

    @Override
    ProductB createProductB() {
        return new ProruductB2();
    }
}
